home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 3: CDPD 3 / Almathera Ten on Ten - Disc 3: CDPD3.iso / fish / 726-750 / 741 / rkrm_lib1 / rkrm_lib1.lha / Intuition / Screens / dualplayfield.c < prev    next >
C/C++ Source or Header  |  1992-09-03  |  7KB  |  263 lines
  1. ;/* dualplayfield.c - Shows how to turn on dual-playfield mode in a screen.
  2. lc -b1 -cfist -v -y -j73 dualplayfield
  3. blink FROM LIB:c.o dualplayfield.o TO dualplayfield LIB LIB:lc.lib LIB:amiga.lib
  4. quit
  5. */
  6.  
  7. /*
  8. Copyright (c) 1992 Commodore-Amiga, Inc.
  9.  
  10. This example is provided in electronic form by Commodore-Amiga, Inc. for
  11. use with the "Amiga ROM Kernel Reference Manual: Libraries", 3rd Edition,
  12. published by Addison-Wesley (ISBN 0-201-56774-1).
  13.  
  14. The "Amiga ROM Kernel Reference Manual: Libraries" contains additional
  15. information on the correct usage of the techniques and operating system
  16. functions presented in these examples.  The source and executable code
  17. of these examples may only be distributed in free electronic form, via
  18. bulletin board or as part of a fully non-commercial and freely
  19. redistributable diskette.  Both the source and executable code (including
  20. comments) must be included, without modification, in any copy.  This
  21. example may not be published in printed form or distributed with any
  22. commercial product.  However, the programming techniques and support
  23. routines set forth in these examples may be used in the development
  24. of original executable software products for Commodore Amiga computers.
  25.  
  26. All other rights reserved.
  27.  
  28. This example is provided "as-is" and is subject to change; no
  29. warranties are made.  All use is at your own risk. No liability or
  30. responsibility is assumed.
  31. */
  32.  
  33.  
  34. #define INTUI_V36_NAMES_ONLY
  35.  
  36. #include <exec/types.h>
  37. #include <exec/memory.h>
  38. #include <intuition/intuition.h>
  39. #include <graphics/displayinfo.h>
  40.  
  41. #include <clib/exec_protos.h>
  42. #include <clib/intuition_protos.h>
  43. #include <clib/graphics_protos.h>
  44.  
  45. VOID doDualPF ( struct Window * );
  46. BOOL installDualPF( struct Screen *, struct RastInfo * );
  47. VOID drawSomething( struct RastPort * );
  48. VOID handleIDCMP ( struct Window * );
  49. VOID removeDualPF( struct Screen *s );
  50.  
  51. struct Library *IntuitionBase;
  52. struct Library *GfxBase;
  53.  
  54. VOID main(int argc, char **argv)
  55. {
  56. struct Window *win;
  57. struct Screen *scr;
  58.  
  59. IntuitionBase = OpenLibrary("intuition.library",37);
  60. if (IntuitionBase != NULL)
  61.     {
  62.     GfxBase = OpenLibrary("graphics.library", 37);
  63.     if (GfxBase != NULL)
  64.         {
  65.         scr = OpenScreenTags(NULL,
  66.                              SA_Depth,     2,
  67.                              SA_DisplayID, HIRES_KEY,
  68.                              SA_Title,     "Dual Playfield Test Screen",
  69.                              TAG_END);
  70.         if ( scr != NULL )
  71.             {
  72.             win = OpenWindowTags(NULL,
  73.                                  WA_Title,        "Dual Playfield Mode",
  74.                                  WA_IDCMP,        IDCMP_CLOSEWINDOW,
  75.                                  WA_Width,        200,
  76.                                  WA_Height,       100,
  77.                                  WA_DragBar,      TRUE,
  78.                                  WA_CloseGadget,  TRUE,
  79.                                  WA_CustomScreen, scr,
  80.                                  TAG_END);
  81.             if ( win != NULL )
  82.                 {
  83.                 doDualPF(win);
  84.  
  85.                 CloseWindow(win);
  86.                 }
  87.             CloseScreen(scr);
  88.             }
  89.         CloseLibrary(GfxBase);
  90.         }
  91.     CloseLibrary(IntuitionBase);
  92.     }
  93. }
  94.  
  95.  
  96. /*
  97. ** Allocate all of the stuff required to add dual playfield to a screen.
  98. */
  99. VOID doDualPF(struct Window *win)
  100. {
  101. struct Screen   *myscreen;
  102. struct RasInfo  *rinfo2;
  103. struct BitMap   *bmap2;
  104. struct RastPort *rport2;
  105.  
  106. myscreen = win->WScreen;   /* Find the window's screen */
  107.  
  108. /* Allocate the second playfield's rasinfo, bitmap, and bitplane */
  109. rinfo2 = (struct RasInfo *) AllocMem(sizeof(struct RasInfo), MEMF_PUBLIC | MEMF_CLEAR);
  110. if ( rinfo2 != NULL )
  111.     {
  112.     /* Get a rastport, and set it up for rendering into bmap2 */
  113.     rport2 = (struct RastPort *) AllocMem(sizeof(struct RastPort), MEMF_PUBLIC );
  114.     if (rport2 != NULL )
  115.         {
  116.         bmap2 = (struct BitMap *) AllocMem(sizeof(struct BitMap), MEMF_PUBLIC | MEMF_CLEAR);
  117.         if (bmap2 != NULL )
  118.             {
  119.             InitBitMap(bmap2, 1, myscreen->Width, myscreen->Height);
  120.  
  121.             /* extra playfield will only use one bitplane here. */
  122.             bmap2->Planes[0] = (PLANEPTR) AllocRaster(myscreen->Width, myscreen->Height);
  123.             if (bmap2->Planes[0] != NULL )
  124.                 {
  125.                 InitRastPort(rport2);
  126.                 rport2->BitMap = rinfo2->BitMap = bmap2;
  127.  
  128.                 SetRast(rport2, 0);
  129.  
  130.                 if (installDualPF(myscreen,rinfo2))
  131.                     {
  132.                     /* Set foreground color; color 9 is color 1 for
  133.                     ** second playfield of hi-res viewport
  134.                     */
  135.                     SetRGB4(&myscreen->ViewPort, 9, 0, 0xF, 0);
  136.  
  137.                     drawSomething(rport2);
  138.  
  139.                     handleIDCMP(win);
  140.  
  141.                     removeDualPF(myscreen);
  142.                     }
  143.                 FreeRaster(bmap2->Planes[0], myscreen->Width, myscreen->Height);
  144.                 }
  145.             FreeMem(bmap2, sizeof(struct BitMap));
  146.             }
  147.         FreeMem(rport2, sizeof(struct RastPort));
  148.         }
  149.     FreeMem(rinfo2, sizeof(struct RasInfo));
  150.     }
  151. }
  152.  
  153.  
  154. /*
  155. ** Manhandle the viewport:
  156. ** install second playfield and change modes
  157. */
  158. BOOL installDualPF(struct Screen *scrn, struct RastInfo *rinfo2)
  159. {
  160. ULONG screen_modeID;
  161. BOOL return_code = FALSE;
  162.  
  163. screen_modeID = GetVPModeID(&(scrn->ViewPort));
  164. if( screen_modeID != INVALID_ID )
  165.     {
  166.     /* you can only play with the bits in the Modes field
  167.     ** if the upper half of the screen mode ID is zero!!!
  168.     */
  169.     if ( (screen_modeID & 0xFFFF0000L) == 0L )
  170.         {
  171.         return_code = TRUE;
  172.  
  173.         Forbid();
  174.  
  175.         /* Install rinfo for viewport's second playfield */
  176.         scrn->ViewPort.RasInfo->Next = rinfo2;
  177.         scrn->ViewPort.Modes |= DUALPF;
  178.  
  179.         Permit();
  180.  
  181.         /* Put viewport change into effect */
  182.         MakeScreen(scrn);
  183.         RethinkDisplay();
  184.         }
  185.     }
  186. return(return_code);
  187. }
  188.  
  189. /*
  190. ** Draw some lines in a rast port...This is used to get some data into
  191. ** the second playfield.  The windows on the screen will move underneath
  192. ** these graphics without disturbing them.
  193. */
  194. VOID drawSomething(struct RastPort *rp)
  195. {
  196. int width, height;
  197. int r, c;
  198.  
  199. width = rp->BitMap->BytesPerRow * 8;
  200. height = rp->BitMap->Rows;
  201.  
  202. SetAPen(rp, 1);
  203.  
  204. for (r = 0; r < height; r += 40)
  205.     {
  206.     for (c = 0; c < width; c += 40)
  207.         {
  208.         Move(rp, 0L, r);
  209.         Draw(rp, c, 0L);
  210.         }
  211.     }
  212. }
  213.  
  214. /*
  215. ** simple event loop to wait for the user to hit the close gadget
  216. ** on the window.
  217. */
  218. VOID handleIDCMP(struct Window *win)
  219. {
  220. BOOL done = FALSE;
  221. struct IntuiMessage *message = NULL;
  222. ULONG class;
  223. ULONG signals;
  224.  
  225. while (!done)
  226.     {
  227.     signals = Wait(1L << win->UserPort->mp_SigBit);
  228.     if (signals & (1L << win->UserPort->mp_SigBit))
  229.         {
  230.         while ((!done) &&
  231.                (message = (struct IntuiMessage *)GetMsg(win->UserPort)))
  232.             {
  233.             class = message->Class;
  234.             ReplyMsg((struct Message *)message);
  235.  
  236.             switch (class)
  237.                 {
  238.                 case IDCMP_CLOSEWINDOW:
  239.                     done = TRUE;
  240.                     break;
  241.                 }
  242.             }
  243.         }
  244.     }
  245. }
  246.  
  247. /*
  248. ** remove the effects of installDualPF().
  249. ** only call if installDualPF() succeeded.
  250. */
  251. VOID removeDualPF(struct Screen *scrn)
  252. {
  253. Forbid();
  254.  
  255. scrn->ViewPort.RasInfo->Next = NULL;
  256. scrn->ViewPort.Modes &= ~DUALPF;
  257.  
  258. Permit();
  259.  
  260. MakeScreen(scrn);
  261. RethinkDisplay();
  262. }
  263.